home *** CD-ROM | disk | FTP | other *** search
/ MPEG Toolkit / MPEG Toolkit.iso / win / mpg2w11b / mpeg2dec / display.c next >
Encoding:
C/C++ Source or Header  |  1997-01-01  |  32.9 KB  |  1,349 lines
  1. /* Copyright (C) 1994, MPEG Software Simulation Group. All Rights Reserved. */
  2.  
  3. /*
  4.  * Disclaimer of Warranty
  5.  *
  6.  * These software programs are available to the user without any license fee or
  7.  * royalty on an "as is" basis.  The MPEG Software Simulation Group disclaims
  8.  * any and all warranties, whether express, implied, or statuary, including any
  9.  * implied warranties or merchantability or of fitness for a particular
  10.  * purpose.  In no event shall the copyright-holder be liable for any
  11.  * incidental, punitive, or consequential damages of any kind whatsoever
  12.  * arising from the use of these programs.
  13.  *
  14.  * This disclaimer of warranty extends to the user of these programs and user's
  15.  * customers, employees, agents, transferees, successors, and assigns.
  16.  *
  17.  * The MPEG Software Simulation Group does not represent or warrant that the
  18.  * programs furnished hereunder are free of infringement of any third-party
  19.  * patents.
  20.  *
  21.  * Commercial implementations of MPEG-1 and MPEG-2 video, including shareware,
  22.  * are subject to royalty fees to patent holders.  Many of these patents are
  23.  * general enough such that they are unavoidable regardless of implementation
  24.  * design.
  25.  *
  26.  */
  27.  
  28.  
  29.  /* these routines are closely modeled after those from
  30.   * mpeg_play 2.0 by the Berkeley Plateau Research Group
  31.   */
  32.  
  33. #ifdef DISPLAY
  34.  
  35. #include <malloc.h>
  36. #include <stdio.h>
  37. #include <stdlib.h>
  38.  
  39. #include "config.h"
  40. #include "global.h"
  41.  
  42. /* private prototypes */
  43. static void ditherframe _ANSI_ARGS_((unsigned char *src[]));
  44. static void dithertop _ANSI_ARGS_((unsigned char *src[], unsigned char *dst));
  45. static void ditherbot _ANSI_ARGS_((unsigned char *src[], unsigned char *dst));
  46. static void dithertop420 _ANSI_ARGS_((unsigned char *src[], unsigned char *dst));
  47. static void ditherbot420 _ANSI_ARGS_((unsigned char *src[], unsigned char *dst));
  48. static void ditherframeRGB _ANSI_ARGS_((unsigned char *src[]));
  49. static void dithertopRGB _ANSI_ARGS_((unsigned char *src[], unsigned char *dst));
  50. static void ditherbotRGB _ANSI_ARGS_((unsigned char *src[], unsigned char *dst));
  51. static void init_ditherRGB _ANSI_ARGS_((void));
  52.  
  53. /* local data */
  54. static unsigned char *dithered_image, *dithered_image2;
  55.  
  56. static unsigned char ytab[256+16];
  57. static unsigned char utab[128+16];
  58. static unsigned char vtab[128+16];
  59. static unsigned char pixel[256];
  60.  
  61. typedef void (*DITHER_FRAME_FUNC)(unsigned char **);
  62. typedef void (*DITHER_FIELD_FUNC)(unsigned char **,unsigned char *);
  63. static DITHER_FRAME_FUNC dither_frame;
  64. static DITHER_FIELD_FUNC dither_even, dither_odd;
  65.  
  66. //888888888888888888888888888888888888
  67.  
  68. /* color space conversion coefficients
  69.  *
  70.  * entries are {crv,cbu,cgu,cgv}
  71.  *
  72.  * crv=(255/224)*65536*(1-cr)/0.5
  73.  * cbu=(255/224)*65536*(1-cb)/0.5
  74.  * cgu=(255/224)*65536*(cb/cg)*(1-cb)/0.5
  75.  * cgv=(255/224)*65536*(cr/cg)*(1-cr)/0.5
  76.  *
  77.  * where Y=cr*R+cg*G+cb*B (cr+cg+cb=1)
  78.  */
  79.  
  80. int convmat[8][4] = {
  81.   {117504, 138453, 13954, 34903}, /* no sequence_display_extension */
  82.   {117504, 138453, 13954, 34903}, /* ITU-R Rec. 709 (1990) */
  83.   {104597, 132201, 25675, 53279}, /* unspecified */
  84.   {104597, 132201, 25675, 53279}, /* reserved */
  85.   {104448, 132798, 24759, 53109}, /* FCC */
  86.   {104597, 132201, 25675, 53279}, /* ITU-R Rec. 624-4 System B, G */
  87.   {104597, 132201, 25675, 53279}, /* SMPTE 170M */
  88.   {117579, 136230, 16907, 35559}  /* SMPTE 240M (1987) */
  89. };
  90.  
  91. /* 4x4 ordered dither
  92.  *
  93.  * threshold pattern:
  94.  *   0  8  2 10
  95.  *  12  4 14  6
  96.  *   3 11  1  9
  97.  *  15  7 13  5
  98.  */
  99.  
  100. void dither(src)
  101. unsigned char *src[];
  102. {
  103.   if (prog_seq)
  104.      dither_frame(src);
  105.   else
  106.   {
  107.     if ((pict_struct==FRAME_PICTURE && topfirst) || pict_struct==BOTTOM_FIELD)
  108.     {
  109.       /* top field first */
  110.       dither_even(src,dithered_image);
  111.       dither_odd (src,dithered_image2);
  112.     }
  113.     else
  114.     {
  115.       /* bottom field first */
  116.       dither_odd (src,dithered_image);
  117.       dither_even(src,dithered_image2);
  118.     }
  119.   }
  120.   display_image(dithered_image);
  121. }
  122.  
  123. static void ditherframe(src)
  124. unsigned char *src[];
  125. {
  126.   int i,j;
  127.   int y,u,v;
  128.   unsigned char *py,*pu,*pv,*dst;
  129.  
  130.   py = src[0];
  131.   pu = src[1];
  132.   pv = src[2];
  133.  
  134. #ifdef _WIN32
  135.   dst = dithered_image+(coded_picture_height-1)*coded_picture_width;
  136. #else
  137.   dst = dithered_image;
  138. #endif
  139.  
  140.   for (j=0; j<coded_picture_height; j+=4)
  141.   {
  142.     /* line j + 0 */
  143.     for (i=0; i<coded_picture_width; i+=4)
  144.     {
  145.       y = *py++;
  146.       u = *pu++ >> 1;
  147.       v = *pv++ >> 1;
  148.       *dst++ = pixel[ytab[y]|utab[u]|vtab[v]];
  149.       y = *py++;
  150.       if (chroma_format==CHROMA444)
  151.       {
  152.         u = *pu++ >> 1;
  153.         v = *pv++ >> 1;
  154.       }
  155.       *dst++ = pixel[ytab[y+8]|utab[u+8]|vtab[v+8]];
  156.       y = *py++;
  157.       u = *pu++ >> 1;
  158.       v = *pv++ >> 1;
  159.       *dst++ = pixel[ytab[y+2]|utab[u+2]|vtab[v+2]];
  160.       y = *py++;
  161.       if (chroma_format==CHROMA444)
  162.       {
  163.         u = *pu++ >> 1;
  164.         v = *pv++ >> 1;
  165.       }
  166.       *dst++ = pixel[ytab[y+10]|utab[u+10]|vtab[v+10]];
  167.     }
  168.  
  169.     if (chroma_format==CHROMA420)
  170.     {
  171.       pu -= chrom_width;
  172.       pv -= chrom_width;
  173.     }
  174.  
  175. #ifdef _WIN32
  176.     dst -= 2*coded_picture_width;
  177. #endif
  178.  
  179.     /* line j + 1 */
  180.     for (i=0; i<coded_picture_width; i+=4)
  181.     {
  182.       y = *py++;
  183.       u = *pu++ >> 1;
  184.       v = *pv++ >> 1;
  185.       *dst++ = pixel[ytab[y+12]|utab[u+12]|vtab[v+12]];
  186.       y = *py++;
  187.       if (chroma_format==CHROMA444)
  188.       {
  189.         u = *pu++ >> 1;
  190.         v = *pv++ >> 1;
  191.       }
  192.       *dst++ = pixel[ytab[y+4]|utab[u+4]|vtab[v+4]];
  193.       y = *py++;
  194.       u = *pu++ >> 1;
  195.       v = *pv++ >> 1;
  196.       *dst++ = pixel[ytab[y+14]|utab[u+14]|vtab[v+14]];
  197.       y = *py++;
  198.       if (chroma_format==CHROMA444)
  199.       {
  200.         u = *pu++ >> 1;
  201.         v = *pv++ >> 1;
  202.       }
  203.       *dst++ = pixel[ytab[y+6]|utab[u+6]|vtab[v+6]];
  204.     }
  205.  
  206. #ifdef _WIN32
  207.     dst -= 2*coded_picture_width;
  208. #endif
  209.  
  210.     /* line j + 2 */
  211.     for (i=0; i<coded_picture_width; i+=4)
  212.     {
  213.       y = *py++;
  214.       u = *pu++ >> 1;
  215.       v = *pv++ >> 1;
  216.       *dst++ = pixel[ytab[y+3]|utab[u+3]|vtab[v+3]];
  217.       y = *py++;
  218.       if (chroma_format==CHROMA444)
  219.       {
  220.         u = *pu++ >> 1;
  221.         v = *pv++ >> 1;
  222.       }
  223.       *dst++ = pixel[ytab[y+11]|utab[u+11]|vtab[v+11]];
  224.       y = *py++;
  225.       u = *pu++ >> 1;
  226.       v = *pv++ >> 1;
  227.       *dst++ = pixel[ytab[y+1]|utab[u+1]|vtab[v+1]];
  228.       y = *py++;
  229.       if (chroma_format==CHROMA444)
  230.       {
  231.         u = *pu++ >> 1;
  232.         v = *pv++ >> 1;
  233.       }
  234.       *dst++ = pixel[ytab[y+9]|utab[u+9]|vtab[v+9]];
  235.     }
  236.  
  237.     if (chroma_format==CHROMA420)
  238.     {
  239.       pu -= chrom_width;
  240.       pv -= chrom_width;
  241.     }
  242.  
  243. #ifdef _WIN32
  244.     dst -= 2*coded_picture_width;
  245. #endif
  246.  
  247.     /* line j + 3 */
  248.     for (i=0; i<coded_picture_width; i+=4)
  249.     {
  250.       y = *py++;
  251.       u = *pu++ >> 1;
  252.       v = *pv++ >> 1;
  253.       *dst++ = pixel[ytab[y+15]|utab[u+15]|vtab[v+15]];
  254.       y = *py++;
  255.       if (chroma_format==CHROMA444)
  256.       {
  257.         u = *pu++ >> 1;
  258.         v = *pv++ >> 1;
  259.       }
  260.       *dst++ = pixel[ytab[y+7]|utab[u+7]|vtab[v+7]];
  261.       y = *py++;
  262.       u = *pu++ >> 1;
  263.       v = *pv++ >> 1;
  264.       *dst++ = pixel[ytab[y+13]|utab[u+13]|vtab[v+13]];
  265.       y = *py++;
  266.       if (chroma_format==CHROMA444)
  267.       {
  268.         u = *pu++ >> 1;
  269.         v = *pv++ >> 1;
  270.       }
  271.       *dst++ = pixel[ytab[y+5]|utab[u+5]|vtab[v+5]];
  272.     }
  273.  
  274. #ifdef _WIN32
  275.     dst -= 2*coded_picture_width;
  276. #endif
  277.   }
  278.  
  279. }
  280.  
  281. static void dithertop(src,dst)
  282. unsigned char *src[];
  283. unsigned char *dst;
  284. {
  285.   int i,j;
  286.   int y,y2,u,v;
  287.   unsigned char *py,*py2,*pu,*pv,*dst2;
  288.  
  289.   py = src[0];
  290.   py2 = src[0] + (coded_picture_width<<1);
  291.   pu = src[1];
  292.   pv = src[2];
  293.  
  294. #ifdef _WIN32
  295.   dst += (coded_picture_height-1)*coded_picture_width;
  296.   dst2 = dst - coded_picture_width;
  297. #else
  298.   dst2 = dst + coded_picture_width;
  299. #endif
  300.  
  301.   for (j=0; j<coded_picture_height; j+=4)
  302.   {
  303.     /* line j + 0, j + 1 */
  304.     for (i=0; i<coded_picture_width; i+=4)
  305.     {
  306.       y = *py++;
  307.       y2 = *py2++;
  308.       u = *pu++ >> 1;
  309.       v = *pv++ >> 1;
  310.       *dst++  = pixel[ytab[y]|utab[u]|vtab[v]];
  311.       *dst2++ = pixel[ytab[((y+y2)>>1)+12]|utab[u+12]|vtab[v+12]];
  312.  
  313.       y = *py++;
  314.       y2 = *py2++;
  315.       if (chroma_format==CHROMA444)
  316.       {
  317.         u = *pu++ >> 1;
  318.         v = *pv++ >> 1;
  319.       }
  320.       *dst++  = pixel[ytab[y+8]|utab[u+8]|vtab[v+8]];
  321.       *dst2++ = pixel[ytab[((y+y2)>>1)+4]|utab[u+4]|vtab[v+4]];
  322.  
  323.       y = *py++;
  324.       y2 = *py2++;
  325.       u = *pu++ >> 1;
  326.       v = *pv++ >> 1;
  327.       *dst++  = pixel[ytab[y+2]|utab[u+2]|vtab[v+2]];
  328.       *dst2++ = pixel[ytab[((y+y2)>>1)+14]|utab[u+14]|vtab[v+14]];
  329.  
  330.       y = *py++;
  331.       y2 = *py2++;
  332.       if (chroma_format==CHROMA444)
  333.       {
  334.         u = *pu++ >> 1;
  335.         v = *pv++ >> 1;
  336.       }
  337.       *dst++  = pixel[ytab[y+10]|utab[u+10]|vtab[v+10]];
  338.       *dst2++ = pixel[ytab[((y+y2)>>1)+6]|utab[u+6]|vtab[v+6]];
  339.     }
  340.  
  341.     py += coded_picture_width;
  342.  
  343.     if (j!=(coded_picture_height-4))
  344.       py2 += coded_picture_width;
  345.     else
  346.       py2 -= coded_picture_width;
  347.  
  348. #ifdef _WIN32
  349.     dst  = dst2 - 2*coded_picture_width;
  350.     dst2 = dst  - coded_picture_width;
  351. #else
  352.     dst += coded_picture_width;
  353.     dst2+= coded_picture_width;
  354. #endif
  355.  
  356.     if (chroma_format==CHROMA420)
  357.     {
  358.       pu -= chrom_width;
  359.       pv -= chrom_width;
  360.     }
  361.     else
  362.     {
  363.       pu += chrom_width;
  364.       pv += chrom_width;
  365.     }
  366.  
  367.     /* line j + 2. j + 3 */
  368.     for (i=0; i<coded_picture_width; i+=4)
  369.     {
  370.       y = *py++;
  371.       y2 = *py2++;
  372.       u = *pu++ >> 1;
  373.       v = *pv++ >> 1;
  374.       *dst++  = pixel[ytab[y+3]|utab[u+3]|vtab[v+3]];
  375.       *dst2++ = pixel[ytab[((y+y2)>>1)+15]|utab[u+15]|vtab[v+15]];
  376.  
  377.       y = *py++;
  378.       y2 = *py2++;
  379.       if (chroma_format==CHROMA444)
  380.       {
  381.         u = *pu++ >> 1;
  382.         v = *pv++ >> 1;
  383.       }
  384.       *dst++  = pixel[ytab[y+11]|utab[u+11]|vtab[v+11]];
  385.       *dst2++ = pixel[ytab[((y+y2)>>1)+7]|utab[u+7]|vtab[v+7]];
  386.  
  387.       y = *py++;
  388.       y2 = *py2++;
  389.       u = *pu++ >> 1;
  390.       v = *pv++ >> 1;
  391.       *dst++  = pixel[ytab[y+1]|utab[u+1]|vtab[v+1]];
  392.       *dst2++ = pixel[ytab[((y+y2)>>1)+13]|utab[u+13]|vtab[v+13]];
  393.  
  394.       y = *py++;
  395.       y2 = *py2++;
  396.       if (chroma_format==CHROMA444)
  397.       {
  398.         u = *pu++ >> 1;
  399.         v = *pv++ >> 1;
  400.       }
  401.       *dst++  = pixel[ytab[y+9]|utab[u+9]|vtab[v+9]];
  402.       *dst2++ = pixel[ytab[((y+y2)>>1)+5]|utab[u+5]|vtab[v+5]];
  403.     }
  404.  
  405.     py += coded_picture_width;
  406.     py2 += coded_picture_width;
  407. #ifdef _WIN32
  408.     dst  = dst2 - 2*coded_picture_width;
  409.     dst2 = dst  - coded_picture_width;
  410. #else
  411.     dst += coded_picture_width;
  412.     dst2+= coded_picture_width;
  413. #endif
  414.     pu += chrom_width;
  415.     pv += chrom_width;
  416.   }
  417. }
  418.  
  419. static void ditherbot(src,dst)
  420. unsigned char *src[];
  421. unsigned char *dst;
  422. {
  423.   int i,j;
  424.   int y,y2,u,v;
  425.   unsigned char *py,*py2,*pu,*pv,*dst2;
  426.  
  427.   py = src[0] + coded_picture_width;
  428.   py2 = py;
  429.   pu = src[1] + chrom_width;
  430.   pv = src[2] + chrom_width;
  431. #ifdef _WIN32
  432.   dst += (coded_picture_height-1)*coded_picture_width;
  433.   dst2 = dst - coded_picture_width;
  434. #else
  435.   dst2 = dst + coded_picture_width;
  436. #endif
  437.  
  438.   for (j=0; j<coded_picture_height; j+=4)
  439.   {
  440.     /* line j + 0, j + 1 */
  441.     for (i=0; i<coded_picture_width; i+=4)
  442.     {
  443.       y = *py++;
  444.       y2 = *py2++;
  445.       u = *pu++ >> 1;
  446.       v = *pv++ >> 1;
  447.       *dst++  = pixel[ytab[((y+y2)>>1)]|utab[u]|vtab[v]];
  448.       *dst2++ = pixel[ytab[y2+12]|utab[u+12]|vtab[v+12]];
  449.  
  450.       y = *py++;
  451.       y2 = *py2++;
  452.       if (chroma_format==CHROMA444)
  453.       {
  454.         u = *pu++ >> 1;
  455.         v = *pv++ >> 1;
  456.       }
  457.       *dst++  = pixel[ytab[y+8]|utab[u+8]|vtab[v+8]];
  458.       *dst2++ = pixel[ytab[y2+4]|utab[u+4]|vtab[v+4]];
  459.  
  460.       y = *py++;
  461.       y2 = *py2++;
  462.       u = *pu++ >> 1;
  463.       v = *pv++ >> 1;
  464.       *dst++  = pixel[ytab[((y+y2)>>1)+2]|utab[u+2]|vtab[v+2]];
  465.       *dst2++ = pixel[ytab[y2+14]|utab[u+14]|vtab[v+14]];
  466.  
  467.       y = *py++;
  468.       y2 = *py2++;
  469.       if (chroma_format==CHROMA444)
  470.       {
  471.         u = *pu++ >> 1;
  472.         v = *pv++ >> 1;
  473.       }
  474.       *dst++  = pixel[ytab[((y+y2)>>1)+10]|utab[u+10]|vtab[v+10]];
  475.       *dst2++ = pixel[ytab[y2+6]|utab[u+6]|vtab[v+6]];
  476.     }
  477.  
  478.     if (j==0)
  479.       py -= coded_picture_width;
  480.     else
  481.       py += coded_picture_width;
  482.  
  483.     py2 += coded_picture_width;
  484. #ifdef _WIN32
  485.     dst  = dst2 - 2*coded_picture_width;
  486.     dst2 = dst  - coded_picture_width;
  487. #else
  488.     dst += coded_picture_width;
  489.     dst2+= coded_picture_width;
  490. #endif
  491.  
  492.     if (chroma_format==CHROMA420)
  493.     {
  494.       pu -= chrom_width;
  495.       pv -= chrom_width;
  496.     }
  497.     else
  498.     {
  499.       pu += chrom_width;
  500.       pv += chrom_width;
  501.     }
  502.  
  503.     /* line j + 2. j + 3 */
  504.     for (i=0; i<coded_picture_width; i+=4)
  505.     {
  506.       y = *py++;
  507.       y2 = *py2++;
  508.       u = *pu++ >> 1;
  509.       v = *pv++ >> 1;
  510.       *dst++  = pixel[ytab[((y+y2)>>1)+3]|utab[u+3]|vtab[v+3]];
  511.       *dst2++ = pixel[ytab[y2+15]|utab[u+15]|vtab[v+15]];
  512.  
  513.       y = *py++;
  514.       y2 = *py2++;
  515.       if (chroma_format==CHROMA444)
  516.       {
  517.         u = *pu++ >> 1;
  518.         v = *pv++ >> 1;
  519.       }
  520.       *dst++  = pixel[ytab[((y+y2)>>1)+11]|utab[u+11]|vtab[v+11]];
  521.       *dst2++ = pixel[ytab[y2+7]|utab[u+7]|vtab[v+7]];
  522.  
  523.       y = *py++;
  524.       y2 = *py2++;
  525.       u = *pu++ >> 1;
  526.       v = *pv++ >> 1;
  527.       *dst++  = pixel[ytab[((y+y2)>>1)+1]|utab[u+1]|vtab[v+1]];
  528.       *dst2++ = pixel[ytab[y2+13]|utab[u+13]|vtab[v+13]];
  529.  
  530.       y = *py++;
  531.       y2 = *py2++;
  532.       if (chroma_format==CHROMA444)
  533.       {
  534.         u = *pu++ >> 1;
  535.         v = *pv++ >> 1;
  536.       }
  537.       *dst++  = pixel[ytab[((y+y2)>>1)+9]|utab[u+9]|vtab[v+9]];
  538.       *dst2++ = pixel[ytab[y2+5]|utab[u+5]|vtab[v+5]];
  539.     }
  540.  
  541.     py += coded_picture_width;
  542.     py2 += coded_picture_width;
  543. #ifdef _WIN32
  544.     dst  = dst2 - 2*coded_picture_width;
  545.     dst2 = dst  - coded_picture_width;
  546. #else
  547.     dst += coded_picture_width;
  548.     dst2+= coded_picture_width;
  549. #endif
  550.     pu += chrom_width;
  551.     pv += chrom_width;
  552.   }
  553. }
  554.  
  555. static void dithertop420(src,dst)
  556. unsigned char *src[];
  557. unsigned char *dst;
  558. {
  559.   int i,j;
  560.   int y1,u1,v1,y2,u2,v2;
  561.   unsigned char *py1,*pu1,*pv1,*py2,*pu2,*pv2,*dst2;
  562.  
  563.   py1 = src[0];
  564.   pu1 = src[1];
  565.   pv1 = src[2];
  566.  
  567.   py2 = py1 + (coded_picture_width<<1);
  568.   pu2 = pu1 + (chrom_width<<1);
  569.   pv2 = pv1 + (chrom_width<<1);
  570.  
  571. #ifdef _WIN32
  572.   dst += (coded_picture_height-1)*coded_picture_width;
  573.   dst2 = dst - coded_picture_width;
  574. #else
  575.   dst2 = dst + coded_picture_width;
  576. #endif
  577.  
  578.   for (j=0; j<coded_picture_height; j+=4)
  579.   {
  580.     /* line j + 0, j + 1 */
  581.     for (i=0; i<coded_picture_width; i+=4)
  582.     {
  583.       y1 = *py1++;
  584.       y2 = *py2++;
  585.       u1 = *pu1++ >> 1;
  586.       v1 = *pv1++ >> 1;
  587.       u2 = *pu2++ >> 1;
  588.       v2 = *pv2++ >> 1;
  589.       *dst++  = pixel[ytab[((3*y1+y2)>>2)]|utab[u1]|vtab[v1]];
  590.       *dst2++ = pixel[ytab[((y1+3*y2)>>2)+12]|utab[((3*u1+u2)>>2)+12]
  591.                                              |vtab[((3*v1+v2)>>2)+12]];
  592.  
  593.       y1 = *py1++;
  594.       y2 = *py2++;
  595.       *dst++  = pixel[ytab[((3*y1+y2)>>2)+8]|utab[u1+8]|vtab[v1+8]];
  596.       *dst2++ = pixel[ytab[((y1+3*y2)>>2)+4]|utab[((3*u1+u2)>>2)+4]
  597.                                             |vtab[((3*v1+v2)>>2)+4]];
  598.  
  599.       y1 = *py1++;
  600.       y2 = *py2++;
  601.       u1 = *pu1++ >> 1;
  602.       v1 = *pv1++ >> 1;
  603.       u2 = *pu2++ >> 1;
  604.       v2 = *pv2++ >> 1;
  605.       *dst++  = pixel[ytab[((3*y1+y2)>>2)+2]|utab[u1+2]|vtab[v1+2]];
  606.       *dst2++ = pixel[ytab[((y1+3*y2)>>2)+14]|utab[((3*u1+u2)>>2)+14]
  607.                                              |vtab[((3*v1+v2)>>2)+14]];
  608.  
  609.       y1 = *py1++;
  610.       y2 = *py2++;
  611.       *dst++  = pixel[ytab[((3*y1+y2)>>2)+10]|utab[u1+10]|vtab[v1+10]];
  612.       *dst2++ = pixel[ytab[((y1+3*y2)>>2)+6]|utab[((3*u1+u2)>>2)+6]
  613.                                             |vtab[((3*v1+v2)>>2)+6]];
  614.     }
  615.  
  616.     py1 += coded_picture_width;
  617.  
  618.     if (j!=(coded_picture_height-4))
  619.       py2 += coded_picture_width;
  620.     else
  621.       py2 -= coded_picture_width;
  622.  
  623.     pu1 -= chrom_width;
  624.     pv1 -= chrom_width;
  625.     pu2 -= chrom_width;
  626.     pv2 -= chrom_width;
  627.  
  628. #ifdef _WIN32
  629.     dst  = dst2 - 2*coded_picture_width;
  630.     dst2 = dst  - coded_picture_width;
  631. #else
  632.     dst += coded_picture_width;
  633.     dst2+= coded_picture_width;
  634. #endif
  635.  
  636.     /* line j + 2, j + 3 */
  637.     for (i=0; i<coded_picture_width; i+=4)
  638.     {
  639.       y1 = *py1++;
  640.       y2 = *py2++;
  641.       u1 = *pu1++ >> 1;
  642.       v1 = *pv1++ >> 1;
  643.       u2 = *pu2++ >> 1;
  644.       v2 = *pv2++ >> 1;
  645.       *dst++  = pixel[ytab[((3*y1+y2)>>2)+3]|utab[((u1+u2)>>1)+3]
  646.                                             |vtab[((v1+v2)>>1)+3]];
  647.       *dst2++ = pixel[ytab[((y1+3*y2)>>2)+15]|utab[((u1+3*u2)>>2)+15]
  648.                                              |vtab[((v1+3*v2)>>2)+15]];
  649.  
  650.       y1 = *py1++;
  651.       y2 = *py2++;
  652.       *dst++  = pixel[ytab[((3*y1+y2)>>2)+11]|utab[((u1+u2)>>1)+11]
  653.                                              |vtab[((v1+v2)>>1)+11]];
  654.       *dst2++ = pixel[ytab[((y1+3*y2)>>2)+7]|utab[((u1+3*u2)>>2)+7]
  655.                                             |vtab[((v1+3*v2)>>2)+7]];
  656.  
  657.       y1 = *py1++;
  658.       y2 = *py2++;
  659.       u1 = *pu1++ >> 1;
  660.       v1 = *pv1++ >> 1;
  661.       u2 = *pu2++ >> 1;
  662.       v2 = *pv2++ >> 1;
  663.       *dst++  = pixel[ytab[((3*y1+y2)>>2)+1]|utab[((u1+u2)>>1)+1]
  664.                                             |vtab[((v1+v2)>>1)+1]];
  665.       *dst2++ = pixel[ytab[((y1+3*y2)>>2)+13]|utab[((u1+3*u2)>>2)+13]
  666.                                              |vtab[((v1+3*v2)>>2)+13]];
  667.  
  668.       y1 = *py1++;
  669.       y2 = *py2++;
  670.       *dst++  = pixel[ytab[((3*y1+y2)>>2)+9]|utab[((u1+u2)>>1)+9]
  671.                                             |vtab[((v1+v2)>>1)+9]];
  672.       *dst2++ = pixel[ytab[((y1+3*y2)>>2)+5]|utab[((u1+3*u2)>>2)+5]
  673.                                             |vtab[((v1+3*v2)>>2)+5]];
  674.     }
  675.  
  676.     py1 += coded_picture_width;
  677.     py2 += coded_picture_width;
  678.     pu1 += chrom_width;
  679.     pv1 += chrom_width;
  680.     if (j!=(coded_picture_height-8))
  681.     {
  682.       pu2 += chrom_width;
  683.       pv2 += chrom_width;
  684.     }
  685.     else
  686.     {
  687.       pu2 -= chrom_width;
  688.       pv2 -= chrom_width;
  689.     }
  690. #ifdef _WIN32
  691.     dst  = dst2 - 2*coded_picture_width;
  692.     dst2 = dst  - coded_picture_width;
  693. #else
  694.     dst += coded_picture_width;
  695.     dst2+= coded_picture_width;
  696. #endif
  697.   }
  698. }
  699.  
  700. static void ditherbot420(src,dst)
  701. unsigned char *src[];
  702. unsigned char *dst;
  703. {
  704.   int i,j;
  705.   int y1,u1,v1,y2,u2,v2;
  706.   unsigned char *py1,*pu1,*pv1,*py2,*pu2,*pv2,*dst2;
  707.  
  708.   py2 = py1 = src[0] + coded_picture_width;
  709.   pu2 = pu1 = src[1] + chrom_width;
  710.   pv2 = pv1 = src[2] + chrom_width;
  711.  
  712. #ifdef _WIN32
  713.   dst += (coded_picture_height-1)*coded_picture_width;
  714. #endif
  715.   dst2 = dst;
  716.  
  717.   for (j=0; j<coded_picture_height; j+=4)
  718.   {
  719.     /* line j + 0, j + 1 */
  720.     for (i=0; i<coded_picture_width; i+=4)
  721.     {
  722.       y1 = *py1++;
  723.       y2 = *py2++;
  724.       u1 = *pu1++ >> 1;
  725.       v1 = *pv1++ >> 1;
  726.       u2 = *pu2++ >> 1;
  727.       v2 = *pv2++ >> 1;
  728.       *dst++  = pixel[ytab[((3*y1+y2)>>2)+15]|utab[((3*u1+u2)>>2)+15]
  729.                                              |vtab[((3*v1+v2)>>2)+15]];
  730.       *dst2++ = pixel[ytab[((y1+3*y2)>>2)]|utab[((u1+u2)>>1)]
  731.                                           |vtab[((v1+v2)>>1)]];
  732.  
  733.       y1 = *py1++;
  734.       y2 = *py2++;
  735.       *dst++  = pixel[ytab[((3*y1+y2)>>2)+7]|utab[((3*u1+u2)>>2)+7]
  736.                                             |vtab[((3*v1+v2)>>2)+7]];
  737.       *dst2++ = pixel[ytab[((y1+3*y2)>>2)+8]|utab[((u1+u2)>>1)+8]
  738.                                             |vtab[((v1+v2)>>1)+8]];
  739.  
  740.       y1 = *py1++;
  741.       y2 = *py2++;
  742.       u1 = *pu1++ >> 1;
  743.       v1 = *pv1++ >> 1;
  744.       u2 = *pu2++ >> 1;
  745.       v2 = *pv2++ >> 1;
  746.       *dst++  = pixel[ytab[((3*y1+y2)>>2)+13]|utab[((3*u1+u2)>>2)+13]
  747.                                              |vtab[((3*v1+v2)>>2)+13]];
  748.       *dst2++ = pixel[ytab[((y1+3*y2)>>2)+2]|utab[((u1+u2)>>1)+2]
  749.                                             |vtab[((v1+v2)>>1)+2]];
  750.  
  751.       y1 = *py1++;
  752.       y2 = *py2++;
  753.       *dst++  = pixel[ytab[((3*y1+y2)>>2)+5]|utab[((3*u1+u2)>>2)+5]
  754.                                             |vtab[((3*v1+v2)>>2)+5]];
  755.       *dst2++ = pixel[ytab[((y1+3*y2)>>2)+10]|utab[((u1+u2)>>1)+10]
  756.                                              |vtab[((v1+v2)>>1)+10]];
  757.     }
  758.  
  759.     if (j!=0)
  760.       py1 += coded_picture_width;
  761.     else
  762.       py1 -= coded_picture_width;
  763.  
  764.     py2 += coded_picture_width;
  765.  
  766.     pu1 -= chrom_width;
  767.     pv1 -= chrom_width;
  768.     pu2 -= chrom_width;
  769.     pv2 -= chrom_width;
  770.  
  771. #ifdef _WIN32
  772.     if (j!=0)
  773.        dst  = dst2 - 2*coded_picture_width;
  774.     dst2 = dst  - coded_picture_width;
  775. #else
  776.     if (j!=0)
  777.       dst  += coded_picture_width;
  778.     dst2 += coded_picture_width;
  779. #endif
  780.  
  781.     /* line j + 2, j + 3 */
  782.     for (i=0; i<coded_picture_width; i+=4)
  783.     {
  784.       y1 = *py1++;
  785.       y2 = *py2++;
  786.       u1 = *pu1++ >> 1;
  787.       v1 = *pv1++ >> 1;
  788.       u2 = *pu2++ >> 1;
  789.       v2 = *pv2++ >> 1;
  790.       *dst++  = pixel[ytab[((3*y1+y2)>>2)+12]|utab[((u1+3*u2)>>2)+12]
  791.                                              |vtab[((v1+3*v2)>>2)+12]];
  792.       *dst2++ = pixel[ytab[((y1+3*y2)>>2)+3]|utab[u2+3]
  793.                                             |vtab[v2+3]];
  794.  
  795.       y1 = *py1++;
  796.       y2 = *py2++;
  797.       *dst++  = pixel[ytab[((3*y1+y2)>>2)+4]|utab[((u1+3*u2)>>2)+4]
  798.                                             |vtab[((v1+3*v2)>>2)+4]];
  799.       *dst2++ = pixel[ytab[((y1+3*y2)>>2)+11]|utab[u2+11]
  800.                                              |vtab[v2+11]];
  801.  
  802.       y1 = *py1++;
  803.       y2 = *py2++;
  804.       u1 = *pu1++ >> 1;
  805.       v1 = *pv1++ >> 1;
  806.       u2 = *pu2++ >> 1;
  807.       v2 = *pv2++ >> 1;
  808.       *dst++  = pixel[ytab[((3*y1+y2)>>2)+14]|utab[((u1+3*u2)>>2)+14]
  809.                                              |vtab[((v1+3*v2)>>2)+14]];
  810.       *dst2++ = pixel[ytab[((y1+3*y2)>>2)+1]|utab[u2+1]
  811.                                             |vtab[v2+1]];
  812.  
  813.       y1 = *py1++;
  814.       y2 = *py2++;
  815.       *dst++  = pixel[ytab[((3*y1+y2)>>2)+6]|utab[((u1+3*u2)>>2)+6]
  816.                                             |vtab[((v1+3*v2)>>2)+6]];
  817.       *dst2++ = pixel[ytab[((y1+3*y2)>>2)+9]|utab[u2+9]
  818.                                             |vtab[v2+9]];
  819.     }
  820.  
  821.     py1 += coded_picture_width;
  822.     py2 += coded_picture_width;
  823.  
  824.     if (j!=0)
  825.     {
  826.       pu1 += chrom_width;
  827.       pv1 += chrom_width;
  828.     }
  829.     else
  830.     {
  831.       pu1 -= chrom_width;
  832.       pv1 -= chrom_width;
  833.     }
  834.  
  835.     pu2 += chrom_width;
  836.     pv2 += chrom_width;
  837.  
  838. #ifdef _WIN32
  839.     dst  = dst2 - 2*coded_picture_width;
  840.     dst2 = dst  - coded_picture_width;
  841. #else
  842.     dst += coded_picture_width;
  843.     dst2+= coded_picture_width;
  844. #endif
  845.   }
  846.  
  847.   py2 -= (coded_picture_width<<1);
  848.   pu2 -= (chrom_width<<1);
  849.   pv2 -= (chrom_width<<1);
  850.  
  851.   /* dither last line */
  852.   for (i=0; i<coded_picture_width; i+=4)
  853.   {
  854.     y1 = *py1++;
  855.     y2 = *py2++;
  856.     u1 = *pu1++ >> 1;
  857.     v1 = *pv1++ >> 1;
  858.     u2 = *pu2++ >> 1;
  859.     v2 = *pv2++ >> 1;
  860.     *dst++  = pixel[ytab[((3*y1+y2)>>2)+15]|utab[((3*u1+u2)>>2)+15]
  861.                                            |vtab[((3*v1+v2)>>2)+15]];
  862.  
  863.     y1 = *py1++;
  864.     y2 = *py2++;
  865.     *dst++  = pixel[ytab[((3*y1+y2)>>2)+7]|utab[((3*u1+u2)>>2)+7]
  866.                                           |vtab[((3*v1+v2)>>2)+7]];
  867.  
  868.     y1 = *py1++;
  869.     y2 = *py2++;
  870.     u1 = *pu1++ >> 1;
  871.     v1 = *pv1++ >> 1;
  872.     u2 = *pu2++ >> 1;
  873.     v2 = *pv2++ >> 1;
  874.     *dst++  = pixel[ytab[((3*y1+y2)>>2)+13]|utab[((3*u1+u2)>>2)+13]
  875.                                            |vtab[((3*v1+v2)>>2)+13]];
  876.  
  877.     y1 = *py1++;
  878.     y2 = *py2++;
  879.     *dst++  = pixel[ytab[((3*y1+y2)>>2)+5]|utab[((3*u1+u2)>>2)+5]
  880.                                           |vtab[((3*v1+v2)>>2)+5]];
  881.   }
  882. }
  883.  
  884. void init_dither(int bpp)
  885. {
  886.   int i, v;
  887.  
  888.   if ( bpp==8 )
  889.   {
  890.      dither_frame=ditherframe;
  891.      if (chroma_format==CHROMA420 && hiQdither)
  892.      {
  893.         dither_even =dithertop420;
  894.         dither_odd  =ditherbot420;
  895.      }
  896.      else
  897.      {
  898.         dither_even =dithertop;
  899.         dither_odd  =ditherbot;
  900.      }
  901.   }
  902.   else if ( bpp==24 )
  903.   {
  904.      dither_frame=ditherframeRGB;
  905.      dither_even =dithertopRGB;
  906.      dither_odd  =ditherbotRGB;
  907.      init_ditherRGB();
  908.   }
  909.   else
  910.      error("unsuported dither type");
  911.  
  912.   bpp/=8;
  913.   if(!(dithered_image = (unsigned char *)malloc(bpp*coded_picture_width*
  914.                                                 coded_picture_height)))
  915.     error("malloc failed");
  916.  
  917.   if(!(dithered_image2 = (unsigned char *)malloc(bpp*coded_picture_width*
  918.                                                  coded_picture_height)))
  919.     error("malloc failed");
  920.  
  921.   for (i=-8; i<256+8; i++)
  922.   {
  923.     v = i>>4;
  924.     if (v<1)
  925.       v = 1;
  926.     else if (v>14)
  927.       v = 14;
  928.     ytab[i+8] = v<<4;
  929.   }
  930.  
  931.   for (i=0; i<128+16; i++)
  932.   {
  933.     v = (i-40)>>4;
  934.     if (v<0)
  935.       v = 0;
  936.     else if (v>3)
  937.       v = 3;
  938.     utab[i] = v<<2;
  939.     vtab[i] = v;
  940.   }
  941.  
  942.   for (i=0; i<256; i++)
  943.      pixel[i]=i;
  944. }
  945.  
  946. ////////////////////////////////////////////////////////////////////////////
  947. //
  948. // RGB dithering routines
  949. //
  950. ////////////////////////////////////////////////////////////////////////////
  951.  
  952. #define BITS    8
  953. #define ONE     ((int) 1)
  954. #define CONST_SCALE    (ONE << BITS)
  955. #define ROUND_FACTOR    (ONE << (BITS-1))
  956. #define UP(x)    (((int)(x)) << BITS)
  957. #define DOWN(x)    (((x) + ROUND_FACTOR) >> BITS)
  958. #define FIX(x)  ((int) ((x)*CONST_SCALE + 0.5))
  959. #define CLAMP(ll,x,ul)    ( ((x)<(ll)) ?(ll):( ((x)>(ul)) ?(ul):(x)))
  960.  
  961. static int Cr_r_tab[256];
  962. static int Cb_g_tab[256];
  963. static int Cr_g_tab[256];
  964. static int Cb_b_tab[256];
  965. static int Cy_tab  [256];
  966.  
  967. //
  968. // initialize tables used in YCbCr -> RGB conversion
  969. //
  970. static void init_ditherRGB()
  971. {
  972.    int CR, CB, i;
  973.  
  974.    for (i=0; i<256; i++)
  975.    {
  976.       CB = CR = i - 128;
  977.  
  978.       Cr_r_tab[i] =  FIX(1.40200) * CR;
  979.       Cb_g_tab[i] = -FIX(0.34414) * CB;
  980.       Cr_g_tab[i] = -FIX(0.71414) * CR;
  981.       Cb_b_tab[i] =  FIX(1.77200) * CB;
  982.       Cy_tab  [i] =  FIX(255.0/219.0) * i;
  983.    }
  984. }
  985.  
  986. static void ditherframeRGB(src)
  987. unsigned char *src[];
  988. {
  989.    unsigned char *lum=src[0];
  990.    unsigned char *cb =src[1];
  991.    unsigned char *cr =src[2];
  992.    int            cols=coded_picture_width;
  993.    int            rows=coded_picture_height;
  994.    int            L, CR, CB;
  995.    unsigned char *lum2, *r1, *r2;
  996.    int            x, y;
  997.    int            cr_r;
  998.    int            cr_g;
  999.    int            cb_g;
  1000.    int            cb_b;
  1001.  
  1002. #ifdef _WIN32
  1003.    r1 = dithered_image + (rows - 1) * cols * 3;
  1004.    r2 = r1 - cols * 3;
  1005. #else
  1006.    r1 = dithered_image;
  1007.    r2 = r1 + cols * 3;
  1008. #endif
  1009.  
  1010.    lum2 = lum + cols;
  1011.    for (y=0; y<rows; y+=2)
  1012.    {
  1013.       for (x=0; x<cols; x+=2)
  1014.       {
  1015.          int R, G, B;
  1016.  
  1017.          CR = *cr++;
  1018.          CB = *cb++;
  1019.          cr_r = Cr_r_tab[CR];
  1020.          cr_g = Cr_g_tab[CR];
  1021.          cb_g = Cb_g_tab[CB];
  1022.          cb_b = Cb_b_tab[CB];
  1023.  
  1024.          L = *lum++;
  1025.          L = Cy_tab[L];
  1026.          R = L + cr_r;
  1027.          G = L + cr_g + cb_g;
  1028.          B = L + cb_b;
  1029.  
  1030.          *r1++ = CLAMP(0,B,UP(255)) >> BITS;
  1031.          *r1++ = CLAMP(0,G,UP(255)) >> BITS;
  1032.          *r1++ = CLAMP(0,R,UP(255)) >> BITS;
  1033.  
  1034.          L = *lum++;
  1035.          L = Cy_tab[L];
  1036.          if (chroma_format==CHROMA444)
  1037.          {
  1038.             CR = *cr;
  1039.             CB = *cb;
  1040.             cr_r = Cr_r_tab[CR];
  1041.             cr_g = Cr_g_tab[CR];
  1042.             cb_g = Cb_g_tab[CB];
  1043.             cb_b = Cb_b_tab[CB];
  1044.          }
  1045.          R = L + cr_r;
  1046.          G = L + cr_g + cb_g;
  1047.          B = L + cb_b;
  1048.  
  1049.          *r1++ = CLAMP(0,B,UP(255)) >> BITS;
  1050.          *r1++ = CLAMP(0,G,UP(255)) >> BITS;
  1051.          *r1++ = CLAMP(0,R,UP(255)) >> BITS;
  1052.  
  1053.          /*
  1054.           * Now, do second row.
  1055.           */
  1056.          if (chroma_format!=CHROMA420)
  1057.          {
  1058.             CR = cr[chrom_width-1];
  1059.             CB = cb[chrom_width-1];
  1060.             cr_r = Cr_r_tab[CR];
  1061.             cr_g = Cr_g_tab[CR];
  1062.             cb_g = Cb_g_tab[CB];
  1063.             cb_b = Cb_b_tab[CB];
  1064.          }
  1065.          L = *lum2++;
  1066.          L = Cy_tab[L];
  1067.          R = L + cr_r;
  1068.          G = L + cr_g + cb_g;
  1069.          B = L + cb_b;
  1070.  
  1071.          *r2++ = CLAMP(0,B,UP(255)) >> BITS;
  1072.          *r2++ = CLAMP(0,G,UP(255)) >> BITS;
  1073.          *r2++ = CLAMP(0,R,UP(255)) >> BITS;
  1074.  
  1075.          L = *lum2++;
  1076.          L = Cy_tab[L];
  1077.          if (chroma_format==CHROMA444)
  1078.          {
  1079.             CR = cr[chrom_width];
  1080.             CB = cb[chrom_width];
  1081.             cr_r = Cr_r_tab[CR];
  1082.             cr_g = Cr_g_tab[CR];
  1083.             cb_g = Cb_g_tab[CB];
  1084.             cb_b = Cb_b_tab[CB];
  1085.             cr++;
  1086.             cb++;
  1087.          }
  1088.          R = L + cr_r;
  1089.          G = L + cr_g + cb_g;
  1090.          B = L + cb_b;
  1091.  
  1092.          *r2++ = CLAMP(0,B,UP(255)) >> BITS;
  1093.          *r2++ = CLAMP(0,G,UP(255)) >> BITS;
  1094.          *r2++ = CLAMP(0,R,UP(255)) >> BITS;
  1095.       }
  1096.       lum += cols;
  1097.       lum2 += cols;
  1098.       if (chroma_format!=CHROMA420)
  1099.       {
  1100.          cr += chrom_width;
  1101.          cb += chrom_width;
  1102.       }
  1103. #ifdef _WIN32
  1104.       r1 -= 9 * cols;
  1105.       r2 -= 9 * cols;
  1106. #else
  1107.       r1 += 3 * cols;
  1108.       r2 += 3 * cols;
  1109. #endif
  1110.    }
  1111. }
  1112.  
  1113. static void dithertopRGB(src,dst)
  1114. unsigned char *src[];
  1115. unsigned char *dst;
  1116. {
  1117.    unsigned char *lum=src[0];
  1118.    unsigned char *cb =src[1];
  1119.    unsigned char *cr =src[2];
  1120.    int            cols=coded_picture_width;
  1121.    int            rows=coded_picture_height;
  1122.    int            L, CR, CB;
  1123.    unsigned char *lum2, *r1, *r2;
  1124.    int            x, y;
  1125.    int            cr_r;
  1126.    int            cr_g;
  1127.    int            cb_g;
  1128.    int            cb_b;
  1129.    int            chrom_offset[3];
  1130.  
  1131.    if (chroma_format==CHROMA420)
  1132.       chrom_offset[0] = -chrom_width;
  1133.    else
  1134.       chrom_offset[0] =  chrom_width;
  1135.    chrom_offset[2] =  chrom_width;
  1136.  
  1137. #ifdef _WIN32
  1138.    r1 = dst + (rows - 1) * cols * 3;
  1139.    r2 = r1 - cols * 3;
  1140. #else
  1141.    r1 = dst;
  1142.    r2 = r1 + cols * 3;
  1143. #endif
  1144.  
  1145.    lum2 = lum + 2*cols;
  1146.    for (y=0; y<rows; y+=2)
  1147.    {
  1148.       for (x=0; x<cols; x+=2)
  1149.       {
  1150.          int R, G, B, Y;
  1151.  
  1152.          CR = *cr++;
  1153.          CB = *cb++;
  1154.          cr_r = Cr_r_tab[CR];
  1155.          cr_g = Cr_g_tab[CR];
  1156.          cb_g = Cb_g_tab[CB];
  1157.          cb_b = Cb_b_tab[CB];
  1158.  
  1159.          Y = *lum++;
  1160.          L = Cy_tab[Y];
  1161.          R = L + cr_r;
  1162.          G = L + cr_g + cb_g;
  1163.          B = L + cb_b;
  1164.  
  1165.          *r1++ = CLAMP(0,B,UP(255)) >> BITS;
  1166.          *r1++ = CLAMP(0,G,UP(255)) >> BITS;
  1167.          *r1++ = CLAMP(0,R,UP(255)) >> BITS;
  1168.  
  1169.          L = (Y + *lum2++)>>1;
  1170.          L = Cy_tab[L];
  1171.          R = L + cr_r;
  1172.          G = L + cr_g + cb_g;
  1173.          B = L + cb_b;
  1174.  
  1175.          *r2++ = CLAMP(0,B,UP(255)) >> BITS;
  1176.          *r2++ = CLAMP(0,G,UP(255)) >> BITS;
  1177.          *r2++ = CLAMP(0,R,UP(255)) >> BITS;
  1178.  
  1179.          Y = *lum++;
  1180.          L = Cy_tab[Y];
  1181.          if (chroma_format==CHROMA444)
  1182.          {
  1183.             CR = *cr++;
  1184.             CB = *cb++;
  1185.             cr_r = Cr_r_tab[CR];
  1186.             cr_g = Cr_g_tab[CR];
  1187.             cb_g = Cb_g_tab[CB];
  1188.             cb_b = Cb_b_tab[CB];
  1189.          }
  1190.          R = L + cr_r;
  1191.          G = L + cr_g + cb_g;
  1192.          B = L + cb_b;
  1193.  
  1194.          *r1++ = CLAMP(0,B,UP(255)) >> BITS;
  1195.          *r1++ = CLAMP(0,G,UP(255)) >> BITS;
  1196.          *r1++ = CLAMP(0,R,UP(255)) >> BITS;
  1197.  
  1198.          L = (Y + *lum2++)>>1;
  1199.          L = Cy_tab[L];
  1200.          R = L + cr_r;
  1201.          G = L + cr_g + cb_g;
  1202.          B = L + cb_b;
  1203.  
  1204.          *r2++ = CLAMP(0,B,UP(255)) >> BITS;
  1205.          *r2++ = CLAMP(0,G,UP(255)) >> BITS;
  1206.          *r2++ = CLAMP(0,R,UP(255)) >> BITS;
  1207.       }
  1208.       lum += cols;
  1209.       if (y!=(rows-2))
  1210.         lum2 += cols;
  1211.       else
  1212.         lum2 -= cols;
  1213.       cb += chrom_offset[y & 2];
  1214.       cr += chrom_offset[y & 2];
  1215. #ifdef _WIN32
  1216.       r1 -= 9 * cols;
  1217.       r2 -= 9 * cols;
  1218. #else
  1219.       r1 += 3 * cols;
  1220.       r2 += 3 * cols;
  1221. #endif
  1222.    }
  1223. }
  1224.  
  1225. static void ditherbotRGB(src,dst)
  1226. unsigned char *src[];
  1227. unsigned char *dst;
  1228. {
  1229.    unsigned char *lum=src[0];
  1230.    unsigned char *cb =src[1] + chrom_width;
  1231.    unsigned char *cr =src[2] + chrom_width;
  1232.    int            cols=coded_picture_width;
  1233.    int            rows=coded_picture_height;
  1234.    int            L, CR, CB;
  1235.    unsigned char *lum2, *r1, *r2;
  1236.    int            x, y;
  1237.    int            cr_r;
  1238.    int            cr_g;
  1239.    int            cb_g;
  1240.    int            cb_b;
  1241.    int            chrom_offset[3];
  1242.  
  1243.    if (chroma_format==CHROMA420)
  1244.       chrom_offset[0] = -chrom_width;
  1245.    else
  1246.       chrom_offset[0] =  chrom_width;
  1247.    chrom_offset[2] =  chrom_width;
  1248.  
  1249. #ifdef _WIN32
  1250.    r1 = dst + (rows - 1) * cols * 3;
  1251.    r2 = r1 - cols * 3;
  1252. #else
  1253.    r1 = dst;
  1254.    r2 = r1 + cols * 3;
  1255. #endif
  1256.  
  1257.    lum +=cols;
  1258.    lum2 =lum;
  1259.    for (y=0; y<rows; y+=2)
  1260.    {
  1261.       for (x=0; x<cols; x+=2)
  1262.       {
  1263.          int R, G, B, Y;
  1264.  
  1265.          CR = *cr++;
  1266.          CB = *cb++;
  1267.          cr_r = Cr_r_tab[CR];
  1268.          cr_g = Cr_g_tab[CR];
  1269.          cb_g = Cb_g_tab[CB];
  1270.          cb_b = Cb_b_tab[CB];
  1271.  
  1272.          Y = *lum++;
  1273.          L = Cy_tab[Y];
  1274.          R = L + cr_r;
  1275.          G = L + cr_g + cb_g;
  1276.          B = L + cb_b;
  1277.  
  1278.          *r1++ = CLAMP(0,B,UP(255)) >> BITS;
  1279.          *r1++ = CLAMP(0,G,UP(255)) >> BITS;
  1280.          *r1++ = CLAMP(0,R,UP(255)) >> BITS;
  1281.  
  1282.          L = (Y + *lum2++)>>1;
  1283.          L = Cy_tab[L];
  1284.          R = L + cr_r;
  1285.          G = L + cr_g + cb_g;
  1286.          B = L + cb_b;
  1287.  
  1288.          *r2++ = CLAMP(0,B,UP(255)) >> BITS;
  1289.          *r2++ = CLAMP(0,G,UP(255)) >> BITS;
  1290.          *r2++ = CLAMP(0,R,UP(255)) >> BITS;
  1291.  
  1292.          Y = *lum++;
  1293.          L = Cy_tab[Y];
  1294.          if (chroma_format==CHROMA444)
  1295.          {
  1296.             CR = *cr++;
  1297.             CB = *cb++;
  1298.             cr_r = Cr_r_tab[CR];
  1299.             cr_g = Cr_g_tab[CR];
  1300.             cb_g = Cb_g_tab[CB];
  1301.             cb_b = Cb_b_tab[CB];
  1302.          }
  1303.          R = L + cr_r;
  1304.          G = L + cr_g + cb_g;
  1305.          B = L + cb_b;
  1306.  
  1307.          *r1++ = CLAMP(0,B,UP(255)) >> BITS;
  1308.          *r1++ = CLAMP(0,G,UP(255)) >> BITS;
  1309.          *r1++ = CLAMP(0,R,UP(255)) >> BITS;
  1310.  
  1311.          L = (Y + *lum2++)>>1;
  1312.          L = Cy_tab[L];
  1313.          R = L + cr_r;
  1314.          G = L + cr_g + cb_g;
  1315.          B = L + cb_b;
  1316.  
  1317.          *r2++ = CLAMP(0,B,UP(255)) >> BITS;
  1318.          *r2++ = CLAMP(0,G,UP(255)) >> BITS;
  1319.          *r2++ = CLAMP(0,R,UP(255)) >> BITS;
  1320.       }
  1321.       lum += cols;
  1322.       if (y!=0)
  1323.         lum2 += cols;
  1324.       else
  1325.         lum2 -= cols;
  1326.       cb += chrom_offset[y & 2];
  1327.       cr += chrom_offset[y & 2];
  1328. #ifdef _WIN32
  1329.       r1 -= 9 * cols;
  1330.       r2 -= 9 * cols;
  1331. #else
  1332.       r1 += 3 * cols;
  1333.       r2 += 3 * cols;
  1334. #endif
  1335.    }
  1336. }
  1337.  
  1338.  
  1339. //
  1340. // portable display function
  1341. //
  1342. void display_second_field()
  1343. {
  1344.   display_image(dithered_image2);
  1345. }
  1346.  
  1347. #endif // DISPLAY
  1348.  
  1349.